package com.ticket.sass.admin.service.impl;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ticket.sass.admin.dto.output.user.UserListOutput;
import com.ticket.sass.admin.mapper.OrderMapper;
import com.ticket.sass.admin.service.BaseService;
import com.ticket.sass.common.entity.tenant.OrderEntity;
import com.ticket.sass.common.entity.tenant.enums.OrderPayStatus;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author ywb
 * @since 2024-03-07
 */
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, OrderEntity> implements BaseService<OrderEntity> {
    /**
     * 根据用户ID列表获取用户订单统计数据
     *
     * @param userIds 用户ID列表
     * @return 用户订单统计数据映射，键为用户ID，值为订单统计数据
     */
    public Map<Long, UserListOutput.ConsumerData> getOrderStatsByUserIds(List<Long> userIds) {
        if (userIds.size() == 0){
            return new HashMap<>();
        }
        
        // 构建查询条件
        LambdaQueryWrapper<OrderEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(OrderEntity::getUserId, userIds);
        // 执行查询
        List<OrderEntity> orders = baseMapper.selectList(queryWrapper);
        if (orders.size() == 0){
            return new HashMap<>();
        }
        
        
        // 数据聚合
        Map<Long, UserListOutput.ConsumerData> statsMap = new HashMap<>();
        for (OrderEntity order : orders) {
            Long userId = order.getUserId();
            UserListOutput.ConsumerData stats = statsMap.getOrDefault(userId, new UserListOutput.ConsumerData());
            switch (order.getType()) {
                case TICKET ->
                    // 计算购买票次数
                    stats.setPurchaseTicketCount(stats.getPurchaseTicketCount() + 1);
                case COMMODITY ->
                    // 计算卖品次数
                    stats.setCommodityCount(stats.getCommodityCount() + 1);
                
                // 其他类型...
            }
            // 计算购买次数和退票次数
            stats.setPurchaseCount(stats.getPurchaseCount() + 1);
            if (order.getPayStatus() == OrderPayStatus.REFUND_SUCCESS) {
                stats.setRefundCount(stats.getRefundCount() + 1);
            }
            statsMap.put(userId, stats);
        }
        return statsMap;
    }
    
    
    public Map<Long, Short> getOrderChannelsByIds(List<Long> orderIds) {
        if (orderIds.size() == 0){
            return new HashMap<>();
        }
        // 创建 QueryWrapper 来指定查询条件
        QueryWrapper<OrderEntity> queryWrapper = Wrappers.query();
        queryWrapper.in("id", orderIds);
        queryWrapper.select("id", "channel");
        
        // 执行查询
        List<OrderEntity> orders = this.list(queryWrapper);
        
        // 转换为 Map<Long, Short>
        return orders.stream().collect(Collectors.toMap(
            OrderEntity::getId,
            order -> order.getChannel().getValue()
        ));
    }
    
    public List<OrderEntity> listByInMixedId(Long mixedId) {

        // 创建 QueryWrapper 来指定查询条件
        QueryWrapper<OrderEntity> queryWrapper = Wrappers.query();
        queryWrapper.eq("order_mixed_id", mixedId);
        
        // 执行查询
        return this.list(queryWrapper);
    }
    
    public OrderEntity dateCount(Short type, Short payStatus, List<Long> ids)  {
        ids.add(0L);
        QueryWrapper<OrderEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(payStatus != null, "pay_status", payStatus);
        queryWrapper.eq("type", type);
        queryWrapper.in( "id", ids);
        queryWrapper.isNull("deleted_at");
        
        // 执行查询
        return this.baseMapper.dateCount(queryWrapper);
    }

    /**
     * 根据订单类型和支付状态返回订单ID列表
     *
     * @param type        订单类型
     * @param payStatus   支付状态
     * @return 订单ID列表
     */
    public List<Long> idsBy(Short type, Short payStatus) {
        // 创建查询条件包装器
        QueryWrapper<OrderEntity> queryWrapper = new QueryWrapper<>();
        
        // 添加条件：支付状态等于传入的payStatus
        queryWrapper.eq("pay_status", payStatus);
        
        // 添加条件：订单类型等于传入的type
        queryWrapper.eq("type", type);
        
        // 添加条件：deleted_at字段为null，即未被删除的订单
        queryWrapper.isNull("deleted_at");
        
        // 执行查询，获取满足条件的订单ID列表
        // 假设orderMapper是您的MyBatis-Plus映射器，并且已经注入到当前服务中
        // 指定只查询id字段
        queryWrapper.select("id");
        
        // 执行查询，获取满足条件的订单对象列表
        List<OrderEntity> orderEntityList = list(queryWrapper);
        
        // 从查询结果中提取ID，并转换为ID列表
        return orderEntityList.stream()
            .map(OrderEntity::getId)
            .collect(Collectors.toList());
    }
    
    
    /**
     * 根据订单ID更新备注
     *
     * @param id 订单ID
     * @param refundRemark 退款备注
     * @return 更新是否成功
     */
    public void updateRefundRemarkById(Long id, String refundRemark) {
        // 创建一个 UpdateWrapper 实例，并指定更新条件
        UpdateWrapper<OrderEntity> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", id).set("refund_remark", refundRemark);
        
        // 执行更新操作
        this.update(updateWrapper);
    }
}
